home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 22 / Cream of the Crop 22.iso / os2 / ssaver26.zip / SAMPLE.ZIP / MINIRTL.C < prev    next >
C/C++ Source or Header  |  1996-02-26  |  4KB  |  205 lines
  1. /*
  2.     minirtl.c
  3.     mini run time library for use with
  4.     ScreenSaver modules with Borland C++
  5. */
  6. #define INCL_DOS
  7. #define INCL_WIN
  8. #include <os2.h>
  9. #include <string.h>
  10. #include <malloc.h>
  11. #include <memory.h>
  12. #include <process.h>
  13.  
  14. /*
  15.     this part of the file was taken from emx 0.8g
  16.     -- Copyright (c) 1990-1993 by Eberhard Mattes
  17. */
  18.  
  19. void    *memcpy (void *s1, const void *s2, size_t n)
  20. {
  21.     size_t i;
  22.  
  23.     for (i = 0; i < n; ++i)
  24.         ((char *)s1)[i] = ((char *)s2)[i];
  25.     return (s1);
  26. }
  27. void    *memset (void *s, int c, size_t n)
  28. {
  29.     size_t i;
  30.     for (i = 0; i < n; ++i)
  31.         ((char *)s)[i] = (char)c;
  32.     return (s);
  33. }
  34. char    *strcat (char *string1, const char *string2)
  35. {
  36.     char *dst;
  37.     dst = string1;
  38.     while (*dst != 0)
  39.         ++dst;
  40.     while ((*dst = *string2) != 0)
  41.         ++dst, ++string2;
  42.     return (string1);
  43. }
  44. char    *strcpy (char *string1, const char *string2)
  45. {
  46.     char *dst;
  47.     dst = string1;
  48.     while ((*dst = *string2) != 0)
  49.         ++dst, ++string2;
  50.     return (string1);
  51. }
  52. size_t    strlen (const char *string)
  53. {
  54.     size_t i;
  55.     i = 0;
  56.     while (string[i] != 0) ++i;
  57.     return (i);
  58. }
  59.  
  60. static unsigned int __rand = 1;
  61. int    rand()
  62. {
  63.     __rand = __rand * 69069 + 5;
  64.     return ((__rand >> 16) & 0x7fff);
  65. }
  66. void    srand(unsigned int seed)
  67. {
  68.     __rand = seed;
  69. }
  70.  
  71. /*
  72.     the remainder of the file is
  73.     (C) 1993-94 Siegfried Hanisch
  74. */
  75.  
  76. // if 1MB is not enough, increase this value
  77. // the memory is not commited, so it does not use physical memory
  78. // until it is accessed
  79. #define MEMPOOLSIZE        (1024L*1024L)
  80. static    void    *mempool = NULL;
  81.  
  82. void    *calloc(size_t elements, size_t size)
  83. {
  84.     return malloc(elements*size);
  85. }
  86.  
  87. void    *malloc(size_t size)
  88. {
  89.     APIRET    rc;
  90.     size_t    *mem;
  91.     rc = DosSubAllocMem(mempool, (PVOID *)&mem, size+sizeof(size_t));
  92.     if(rc){
  93.         WinAlarm(HWND_DESKTOP, WA_ERROR);
  94.         return NULL;
  95.     }
  96.     mem[0] = size;
  97.     return (void *)(&mem[1]);
  98. }
  99.  
  100. void    free(void *mem)
  101. {
  102.     APIRET    rc;
  103.     size_t    *m;
  104.     m = (size_t *)mem;
  105.     rc = DosSubFreeMem(mempool, &m[-1], m[-1]+sizeof(size_t));
  106.     if(rc){
  107.         WinAlarm(HWND_DESKTOP, WA_ERROR);
  108.     }
  109. }
  110.  
  111. void    *realloc(void *mem, size_t size)
  112. {
  113.     void    *new_mem;
  114.     size_t    *m;
  115.     size_t    old_size;
  116.     m = (size_t *)mem;
  117.     old_size = m[-1];
  118.  
  119.     new_mem = malloc(size);
  120.     memcpy(new_mem, mem, old_size);
  121.     memset(((char *)new_mem)+old_size, 0 , size-old_size);
  122.     free(mem);
  123.     return new_mem;
  124. }
  125.  
  126. char    *strdup(const char *string)
  127. {
  128.     return strcpy(malloc(strlen(string)+1), string);
  129. }
  130.  
  131. BOOL    alloc_heap()
  132. {
  133.     APIRET    rc;
  134.     rc = DosAllocMem((PVOID *)&mempool, MEMPOOLSIZE, PAG_READ|PAG_WRITE);
  135.     if(rc){
  136.         WinAlarm(HWND_DESKTOP, WA_ERROR);
  137.         mempool = NULL;
  138.         return FALSE;
  139.     }
  140.  
  141.     rc = DosSubSetMem(mempool, DOSSUB_INIT|DOSSUB_SPARSE_OBJ, MEMPOOLSIZE);
  142.     if(rc){
  143.         DosFreeMem(mempool);
  144.         WinAlarm(HWND_DESKTOP, WA_ERROR);
  145.         return FALSE;
  146.     }
  147.     return TRUE;
  148. }
  149.  
  150. void    free_heap()
  151. {
  152.     APIRET    rc;
  153.     rc = DosSubUnsetMem(mempool);
  154.     if(rc){
  155.         WinAlarm(HWND_DESKTOP, WA_ERROR);
  156.     }
  157.     rc = DosFreeMem(mempool);
  158.     if(rc){
  159.         WinAlarm(HWND_DESKTOP, WA_ERROR);
  160.     }
  161. }
  162.  
  163. #if defined(__BORLANDC__)
  164. int _beginthread(void (_USERENTRY *__start)(void *), unsigned __stksize, void *__arg)
  165. {
  166.     TID    tid;
  167.     if(DosCreateThread(&tid, (PFNTHREAD)__start, (ULONG)__arg, 2L, __stksize) != 0)
  168.         return -1;
  169.     return tid;
  170. }
  171.  
  172. void    _endthread(void)
  173. {
  174.     DosExit(EXIT_THREAD, 0);
  175. }
  176. #elif defined(__IBMC__)
  177. int    _Optlink beginthread( void(* _Optlink __thread)(void *),
  178.   void *stack, unsigned stack_size, void *arg_list);
  179. {
  180.     TID    tid;
  181.     if(DosCreateThread(&tid, (PFNTHREAD)__thread, (ULONG)arg_list, 2L, stack_size) != 0)
  182.         return -1;
  183.     return tid;
  184. }
  185.  
  186. void    _endthread()
  187. {
  188.     DosExit(EXIT_THREAD, 0);
  189. }
  190. #elif defined(__EMX__)
  191. int    _beginthread(void (*start)(void *arg), void *stack,
  192.   unsigned stack_size, void *arg_list)
  193. {
  194.     TID    tid;
  195.     if(DosCreateThread(&tid, (PFNTHREAD)start, (ULONG)arg_list, 2L, stack_size) != 0)
  196.         return -1;
  197.     return tid;
  198. }
  199.  
  200. void    _endthread()
  201. {
  202.     DosExit(EXIT_THREAD, 0);
  203. }
  204. #endif
  205.